home *** CD-ROM | disk | FTP | other *** search
/ Aminet 52 / Aminet 52 (2002)(GTI - Schatztruhe)[!][Dec 2002].iso / Aminet / game / role / ScottItal.lha / ScottItal / Src / AMIGA6.C next >
C/C++ Source or Header  |  2002-10-28  |  63KB  |  1,836 lines
  1. /*
  2.  *  AMIGA Libs & Functions for Scott-Free
  3.  *
  4.  *  ===================================================================
  5.  *
  6.  *  Version History AMIGA:
  7.  *  Ver ,     Date,     Author, Comment
  8.  *  -------------------------------------------------------------------
  9.  *  1.91 e precedenti: Andreas Aumayr
  10.  *  1.92, 28/10/2002 Betori Alessandro, italian version 
  11.  *  ___________________________________________________________________
  12.  */
  13.  
  14. #define  MAX_HIST 20
  15. #define  MAX_LL   40
  16. #define  PIC       8
  17. #define  COC       7
  18. #define  OVL       6
  19. #define  ANI       5
  20. #define  GOT       4
  21. #define  MOVE      0xc0
  22. #define  FILL      0xc1
  23. #define  NEWPIC    0xff
  24. #define  custom    (*((struct Custom *) 0xDFF000L))
  25.  
  26. #include <exec/memory.h>
  27. #include <pragma/exec_lib.h>
  28. #include <intuition/intuition.h>
  29. #include <graphics/GfxBase.h>
  30. #include <graphics/rpattr.h>
  31. #include <graphics/gfxmacros.h>
  32. #include <graphics/gfx.h>
  33. #include <hardware/dmabits.h>
  34. #include <hardware/custom.h>
  35. #include <workbench/workbench.h>
  36. #include <libraries/dos.h>
  37. #include <libraries/dosextens.h>
  38. #include <dos/exall.h>
  39. #include <utility/tagitem.h>
  40. #include <libraries/asl.h>
  41. #include <libraries/gadtools.h>
  42. #include <workbench/startup.h>
  43. #include <libraries/amigaguide.h>
  44. #include <datatypes/pictureclass.h>
  45. #include <devices/inputevent.h>
  46. #include <exec/types.h>
  47. #include <devices/narrator.h>
  48. #include <libraries/translator.h>
  49. #include "gui.c"
  50.  
  51.  
  52. extern void *indirizzo_puntatore[1024];//Betori
  53. int contatore;//Betori
  54.  
  55. room_pics *rp;
  56. extern struct MsgPort *CreatePort();
  57. extern struct IORequest *CreateExtIO();
  58.  
  59.  
  60.  
  61.  
  62.  
  63. struct MsgPort *narratorPort;
  64. struct RastPort *rastPort;
  65. struct TmpRas tmp;
  66.  
  67.  
  68. struct narrator_rb *request;
  69.  
  70.  
  71.  
  72. STRPTR nartrans[1024];
  73. ULONG  narBuf;
  74. BYTE   channels[4] = {3,5,10,12};
  75.  
  76. struct IntuitionBase *IntuitionBase;
  77. struct GfxBase *GfxBase;
  78.  
  79.  
  80. struct Library* DiskfontBase=NULL;//NULL by Betori
  81. struct Library* IconBase=NULL;//NULL by Betori
  82. struct Library* Dos_Base=NULL;//NULL by Betori
  83. struct Library* UtilityBase=NULL;//NULL by Betori
  84. struct Library* AslBase=NULL;//NULL by Betori
  85. struct Library* GadToolsBase=NULL;//NULL by Betori
  86. struct Library* AmigaGuideBase=NULL;//NULL by Betori
  87. struct Library* DataTypesBase=NULL;//NULL by Betori
  88. struct Library* TranslatorBase=NULL;//NULL by Betori
  89.  
  90. struct Screen *WBscreen = NULL;
  91. struct Screen *ScottScreen = NULL;
  92. ULONG  old_pubmode;
  93. struct Window *act_w_hdl=NULL;//NULL by Betori
  94. struct Window *pic_w_hdl = NULL;
  95. APTR   WBvisinfo = NULL;
  96. struct TextFont *textfont = NULL;
  97. char   save_game[32] = "";
  98. char   data_file[32] = "",data_dir[256] = "";
  99. char   save_dir[256] = "";
  100. char   gfx_file[256] = "";
  101. char   FFP[256];
  102.  
  103. char   hist[MAX_HIST][MAX_LL+1];
  104. int    hist_pos=0,hist_fill=0;
  105.  
  106. struct Menu *menu = NULL;
  107. char   Version[] = "$VER: AMIGA SCOTT-Free V1.92 (italiana), 2002";
  108. char   GameInfoStr[256] = "";
  109.  
  110. struct WBStartup *WBMessage;
  111. struct MsgPort *OldUserPort;
  112. BOOL   WBSTART  = FALSE;
  113. BOOL   RESTART  = TRUE;
  114. BOOL   LINEWRAP = TRUE;
  115. BOOL   GFX      = TRUE;
  116. BOOL   SPEECH   = FALSE;
  117. ULONG  Disp_ID;
  118. BOOL   FASTCOLOURS = FALSE;
  119. BOOL   LDP;
  120. //BOOL   NOGFXPOS = FALSE;
  121. //BOOL   INIT = FALSE;
  122. //BOOL   GFXDOUBLE = FALSE;
  123. char   restart_file[42] = "RAM:";
  124. BPTR   restart_lock;
  125.  
  126. struct NewAmigaGuide scott_guide = {NULL};
  127. int    last_pic = -128;
  128. ULONG  *go = NULL;//NULL Betori era 0
  129. LONG   Pens[16] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
  130. UBYTE  NumColours = 0;
  131. UBYTE  planesN = 0;
  132. struct ColorRegister CR[16];
  133. struct BitMap bitmapN;
  134. int    gfx_width = 0,gfx_height = 0;
  135. WORD   win_pos_ver,win_pos_hor;
  136. int    win_width = -1,win_height;
  137. BYTE   ScreenAspect;
  138. UBYTE  *picture = NULL,*rle_dat = NULL,*overlay = NULL;//Betori erano tutti e tre =0
  139. WORD   w_top;
  140. int    nroom;
  141. LONG   Rmem = 0;
  142. UBYTE  border_width, bar_height;
  143. char    **font_name=NULL;//NULL Betori
  144. char    **cscreen=NULL;//NULL Betori
  145.  
  146. FILE   *gfx_in_file=NULL;//NULL Betori
  147.  
  148. /// Make_FFP
  149. void Make_FFP(char *file, char *dir)
  150. {
  151.   strcpy(FFP,dir);
  152.   AddPart(FFP,file,256);
  153. }///
  154.  
  155. /// GFX_Off
  156. void GFX_Off(void)
  157. {
  158.     GFX = FALSE;
  159.     OffMenu(act_w_hdl,63491);
  160. }///
  161.  
  162. ///CountPlanes
  163. UBYTE CountPlanes(UBYTE Cols)
  164. {
  165.     UBYTE i;
  166.  
  167.     Cols--;
  168.     for (i=0;i<8;i++) {
  169.         if (Cols & (128>>i)) break;
  170.     }
  171.     return((UBYTE) (8-i));
  172. }
  173. ///
  174.  
  175.  
  176.  
  177. /// NoSpeech
  178. void NoSpeech(BYTE status)
  179. {
  180.     switch(status) {
  181.         case 0:
  182.             CloseDevice((IORequest*)request);
  183.         case 1:
  184.             DeleteExtIO(request);
  185.         case 2:
  186.             DeletePort(narratorPort);
  187.         case 3:
  188.             CloseLibrary(TranslatorBase);
  189.             TranslatorBase = 0;
  190.             SPEECH = FALSE;
  191.     }
  192. }///
  193.  
  194. /// close_libs
  195. void close_libs(void)
  196. {
  197.         if (TranslatorBase) NoSpeech(0);
  198.         if (AmigaGuideBase) CloseLibrary(AmigaGuideBase);
  199.         if (GadToolsBase) CloseLibrary(GadToolsBase);
  200.         if (AslBase) CloseLibrary(AslBase);
  201.         if (UtilityBase) CloseLibrary(UtilityBase);
  202.         if (Dos_Base) CloseLibrary(Dos_Base);
  203.         if (IconBase) CloseLibrary(IconBase);
  204.         if (DiskfontBase) CloseLibrary(DiskfontBase);
  205.         if (GfxBase) CloseLibrary((struct Library*)GfxBase);
  206.         if (IntuitionBase) CloseLibrary((struct Library*)IntuitionBase);
  207. }///
  208.  
  209. /// open_libs
  210. BOOL open_libs(void)
  211. {
  212.                 IntuitionBase = (struct IntuitionBase *) OpenLibrary("intuition.library",37);
  213.                 if (IntuitionBase == NULL) {
  214.                         printf("Problemi aprendo Intuition-Lib!\n");
  215.                         return(FALSE);
  216.                 }
  217.                 GfxBase = (struct GfxBase *) OpenLibrary("graphics.library",37);
  218.                 if (GfxBase == NULL) {
  219.                         printf("Problemi aprendo GFX-Lib!\n");
  220.                         return(FALSE);
  221.                 }
  222.                 DiskfontBase = (struct Library *) OpenLibrary("diskfont.library",0);
  223.                 if (DiskfontBase == 0) {
  224.                         EasyRequest(NULL,&Library,NULL,"DiskFont");
  225.                         return(FALSE);
  226.                 }
  227.                 IconBase = (struct Library *)OpenLibrary("icon.library",0);
  228.                 if (IconBase == 0) {
  229.                         printf("Problemi aprendo Icon-Lib!\n");
  230.                         return(FALSE);
  231.                 }
  232.                 Dos_Base = (struct Library *)OpenLibrary("dos.library",0);
  233.                 if (Dos_Base == 0) {
  234.                         printf("Problemi aprendo DOS-Lib!\n");
  235.                         return(FALSE);
  236.                 }
  237.                 UtilityBase = (struct Library *)OpenLibrary("utility.library",0);
  238.                 if (UtilityBase == 0) {
  239.                         printf("Problemi aprendo Utility-Lib!\n");
  240.                         return(FALSE);
  241.                 }
  242.                 AslBase = (struct Library *)OpenLibrary("asl.library",0);
  243.                 if (AslBase == 0) {
  244.                         EasyRequest(NULL,&Library,NULL,"ASL");
  245.                         return(FALSE);
  246.                 }
  247.                 GadToolsBase = (struct Library *)OpenLibrary("gadtools.library",36);
  248.                 if (GadToolsBase == 0) {
  249.                         printf("Problemi aprendo GadTools-Lib!\n");
  250.                         return(FALSE);
  251.                 }
  252.                 AmigaGuideBase = (struct Library *)OpenLibrary("amigaguide.library",0);
  253.                      if (AmigaGuideBase == 0) {//Betori
  254.                         printf("Problemi aprendo AmigaGuide-Lib!\n");
  255.                         return(FALSE);
  256.                 }
  257.                 TranslatorBase = (struct Library *)OpenLibrary("translator.library",0);
  258.                 if (TranslatorBase == 0) {//Betori
  259.                         printf("Problemi aprendo Translator-Lib!\n");
  260.                         return(FALSE);
  261.                 }
  262.                     else {
  263.                     narratorPort = (struct MsgPort *) CreatePort(0,0);
  264.                     if (narratorPort == NULL) NoSpeech(3);
  265.                     else {
  266.                         request = (struct narrator_rb *) CreateExtIO(narratorPort, sizeof(struct narrator_rb));
  267.                         if (request == NULL) NoSpeech(2);
  268.                         else if (OpenDevice("narrator.device",0,(struct IORequest*)request,0)) NoSpeech(1);
  269.                     }
  270.                 }
  271.                 return(TRUE);
  272. }///
  273.  
  274. ///FreeGFXRes
  275. void FreeGFXRes(void)
  276. {
  277.     int     i;
  278.  
  279.     if (gfx_in_file) fclose(gfx_in_file);
  280.     
  281.     if (rp) free(rp);
  282.     if (go) free(go);
  283.  
  284.     if (FASTCOLOURS) for (i=0;i<NumColours;i++) SetRGB4(&WBscreen->ViewPort,i,(Pens[i]&0x0F00)>>8,(Pens[i]&0x00F0)>>4,Pens[i]&0x000F);
  285.     else {
  286.         for (i=0; i<NumColours; i++) {
  287.             if (Pens[i] > 0) ReleasePen(WBscreen->ViewPort.ColorMap,Pens[i]);
  288.             else break;
  289.         }
  290.     }
  291.  
  292.     if (LDP) if (Rmem) FreeRaster((PLANEPTR)Rmem,gfx_width+1,gfx_height+1);
  293.     else {
  294.         for (i=0; i<planesN; i++) {
  295.             if (bitmapN.Planes[i]) FreeRaster(bitmapN.Planes[i],gfx_width,gfx_height);
  296.             else break;
  297.         }
  298.         //Betori, ci pensa la routine close_all a liberare tutta la memoria allocata
  299.         //if (picture) FreeMem(picture,gfx_width*gfx_height);
  300.         //if (rle_dat) FreeMem(rle_dat,gfx_width*gfx_height);
  301.         //if (overlay) FreeMem(overlay,gfx_width*gfx_height);
  302.     }
  303. }///
  304.  
  305. /// close_all
  306. void close_all(void)
  307. {
  308.     int i;
  309.     //{ Betori
  310.     for (i=0;i<1024;i++){
  311.        if (indirizzo_puntatore[i]!=NULL)
  312.           FreeVec(indirizzo_puntatore[i]);
  313.     }//}
  314.     if (restart_lock) UnLock(restart_lock);
  315.     DeleteFile(restart_file);
  316.     if (menu) FreeMenus(menu);
  317.     if (WBvisinfo) FreeVisualInfo(WBvisinfo);
  318.     if (WBscreen) UnlockPubScreen(NULL,WBscreen);
  319.     if (textfont) CloseFont(textfont);
  320.     if (pic_w_hdl) CloseWindow(pic_w_hdl);
  321.     if (act_hdl) {
  322.         act_w_hdl->UserPort = OldUserPort;
  323.         Close((LONG)act_hdl);
  324.     }
  325.     if (env_hdl)
  326.        Close((LONG)env_hdl);
  327.     if (GFX) FreeGFXRes();
  328.     SetPubScreenModes(old_pubmode);
  329.     if (ScottScreen) {
  330.         while (CloseScreen(ScottScreen) == FALSE) EasyRequest(NULL,&ClosePub,NULL,NULL);
  331.     }
  332.     close_libs();
  333. }///
  334.  
  335. /// MemAlloc
  336. void * MemAlloc(int size)
  337. {
  338.     void *t;
  339.     //{
  340.     indirizzo_puntatore[contatore]=t=(void *) AllocVec(size,MEMF_FAST|MEMF_CLEAR);
  341.       if (t == NULL) {
  342.         printf("\nMemoria esaurita!\nUscita dal programma.\n");
  343.         EasyRequest(NULL,&NoMem,NULL,NULL);
  344.         close_all();
  345.         exit(128);
  346.     }
  347.     contatore++; 
  348.     if (contatore>1024){
  349.         printf("\nAllocazione memoria corrotta!\nUscita dal programma.\n");
  350.         EasyRequest(NULL,&NoMem,NULL,NULL);
  351.         close_all();
  352.         exit(128);
  353.     }
  354.     //}Betori
  355.     return(t);
  356. }///
  357.  
  358. /// Open_CON
  359. struct FileHandle *Open_CON(char *type, int left_off, int top_off, int width, int height, char *title, char *flags, char *cscreen)
  360. {
  361.     sprintf(str_buf,"%s:%d/%d/%d/%d/%s/%s/SCREEN %s",type,left_off,top_off,width,height,title,flags,cscreen);
  362.     CON_handle = (struct FileHandle *) Open(str_buf,MODE_NEWFILE);//Betori
  363.     if (!CON_handle) {
  364.         printf("Fallita apertura della finestra di console '%s'!\n",title);
  365.         EasyRequest(NULL,&ConFail,NULL,title);
  366.         close_all();
  367.         exit(99);
  368.     }
  369.     else return(CON_handle);
  370. }///
  371.  
  372. ///dyn_strings
  373. void * dyn_strings(char *cont, BYTE add)
  374. {
  375.         void *mem_ptr;
  376.         if (cont && strlen(cont)) {
  377.                 mem_ptr = MemAlloc(strlen(cont)+1+add);
  378.                 strcpy(mem_ptr,cont);
  379.                 //printf("MemPtr: |%s| at %ld\n",mem_ptr,mem_ptr);
  380.                 return(mem_ptr);
  381.         }
  382.         return(NULL);
  383. }///
  384.  
  385. ///Get_TT
  386. BOOL Get_TT(char *file_name, UWORD *font_size, char **font_name, char *data_file, char *data_dir, char **cscreen)
  387. {
  388.     UBYTE    **tt_base,*fn,file_dir[256] = "";
  389.     struct  DiskObject *diskobj;
  390.     BOOL    tandy = FALSE;
  391.     BYTE    lw;
  392.  
  393.     if (WBSTART) {
  394.         NameFromLock(WBMessage->sm_ArgList->wa_Lock,file_dir,255);
  395.         Make_FFP(file_name,file_dir);
  396.     }
  397.     else strcpy(FFP,file_name);
  398.  
  399.     if ((diskobj = (struct DiskObject *) GetDiskObject(FFP))) {
  400.         tt_base = (UBYTE **)diskobj->do_ToolTypes;
  401.         fn = (char *) FindToolType(tt_base,"FONT_NAME");
  402.         if (fn) {
  403.             *font_name = dyn_strings(fn,5);
  404.             strcat(*font_name,".font");
  405.             *font_size = (UWORD) abs(atoi((char *) FindToolType(tt_base,"FONT_SIZE")));
  406.         }
  407.         *cscreen = dyn_strings((char *) FindToolType(tt_base,"PUBLICSCREEN"),0);
  408.         if (FindToolType(tt_base,"ADV_DATAFILE")) strncpy(data_file,(char *) FindToolType(tt_base,"ADV_DATAFILE"),31);
  409.         if (FindToolType(tt_base,"ADV_DIR")) {
  410.             Make_FFP((char *) FindToolType(tt_base,"ADV_DIR"),file_dir);
  411.             strncpy(data_dir,FFP,255);
  412.         }
  413.         if (FindToolType(tt_base,"SAVE_GAME")) strncpy(save_game,(char *) FindToolType(tt_base,"SAVE_GAME"),31);
  414.         if (FindToolType(tt_base,"SAVE_DIR")) {
  415.             Make_FFP((char *) FindToolType(tt_base,"SAVE_DIR"),file_dir);
  416.             strncpy(save_dir,FFP,255);
  417.         }
  418.         lw = (BYTE) abs(atoi((char *) FindToolType(tt_base,"LINEWIDTH")));
  419.         if ((lw > 0) && (lw <= 99)) Width = lw;
  420.         if (Strnicmp(FindToolType(tt_base,"TANDYFLAG"),"ON",2) == 0) tandy = TRUE;
  421.         if (Strnicmp(FindToolType(tt_base,"FASTCOLOURS"),"ON",2) == 0) FASTCOLOURS = TRUE;
  422.         if (Strnicmp(FindToolType(tt_base,"LINEWRAP"),"OFF",3) == 0) LINEWRAP = FALSE;
  423.         Disp_ID = strtoul((char *) FindToolType(tt_base,"DISPLAY"),NULL,0);
  424.         //printf("|%s|, |%s|, |%s|, |%s|, |%s,%d|, |%s|\n",save_game,save_dir,data_file,data_dir,*font_name,*font_size,*cscreen);
  425.         if (FindToolType(tt_base,"SPEECH") && TranslatorBase) SPEECH = TRUE;
  426.         FreeDiskObject(diskobj);
  427.     }
  428.     else {
  429.         *font_name = dyn_strings("",0);
  430.         *cscreen   = dyn_strings("",0);
  431.     }
  432.     return(tandy);
  433. }///
  434.  
  435. /// Get_Font
  436. void Get_Font(UWORD font_ysize, char *font_name)
  437. {
  438.     struct TextAttr textattr;
  439.  
  440.     textattr.ta_Name =  font_name;
  441.     textattr.ta_YSize = font_ysize;
  442.     textattr.ta_Style = FS_NORMAL;
  443.     textattr.ta_Flags = FPF_DISKFONT|FPF_DESIGNED;
  444.     if ((textfont = (struct TextFont *) OpenDiskFont(&textattr))) {
  445.         if (textfont->tf_Flags & FPF_PROPORTIONAL) {
  446.             EasyRequest(NULL,&NoProp,NULL,textfont->tf_Message.mn_Node.ln_Name);
  447.             close_all();
  448.             Exit(50);
  449.         }
  450.     }
  451. }///
  452.  
  453. /// Set_NewFont
  454. void Set_NewFont(void)
  455. {
  456.         struct Window *win, *env_w_hdl = NULL;
  457.  
  458.         win = WBscreen->FirstWindow;
  459.         do {
  460.                 if (strncmp(win->Title,"Environment",11) == 0) env_w_hdl = win;
  461.                 if (strncmp(win->Title,"SCOTT-Free AMIGA",16) == 0) act_w_hdl = win;
  462.                 if ((env_w_hdl) && (act_w_hdl)) break;
  463.         } while ((win = win->NextWindow));
  464.  
  465.         if (textfont) {
  466.             SetFont(act_w_hdl->RPort,textfont);
  467.             SetFont(env_w_hdl->RPort,textfont);
  468.         }
  469. }///
  470.  
  471.  
  472.  
  473. ///Init_GFX
  474. void Init_GFX(void)
  475. {
  476.     int i;
  477.     LONG maxPen=0;
  478.  
  479.     fseek(gfx_in_file,go[1],SEEK_SET);
  480.     NumColours = fgetc(gfx_in_file); // how many colours
  481.     //printf("Screen %d, Cols %d\n",1<<WBscreen->RastPort.BitMap->Depth,NumColours);
  482.     if ((1<<WBscreen->RastPort.BitMap->Depth) < NumColours) {
  483.         GFX_Off();
  484.         //NOGFXPOS = TRUE;
  485.         EasyRequest(act_w_hdl,&NoGFX,NULL,"Lo schermo ha pochi colori.\nGFX verrà esclusa.");
  486.         return;
  487.     }
  488.  
  489.     border_width = (UBYTE) WBscreen->WBorLeft;
  490.     bar_height = (UBYTE) WBscreen->WBorTop + WBscreen->Font->ta_YSize + 1;
  491.     win_width = (int) (border_width + (BYTE) WBscreen->WBorRight + gfx_width);
  492.     win_height = (int) (bar_height + (UBYTE) WBscreen->WBorBottom + gfx_height);
  493.     win_pos_hor = w_top - win_height;
  494.     if (win_pos_hor < (WBscreen->BarHeight + 1)) win_pos_hor = (WORD) WBscreen->BarHeight + 1;
  495.     win_pos_ver = (WORD) ((WBscreen->Width - win_width) / 2);
  496.     if (FASTCOLOURS) {
  497.         if (!LDP) planesN = CountPlanes(NumColours);
  498.         //printf("Planes, Cols, Scrn: %d,%d,%d\n",planesN,NumColours,WBscreen->RastPort.BitMap->Depth);
  499.         for (i=0;i<NumColours;i++) Pens[i] = GetRGB4(WBscreen->ViewPort.ColorMap,i);
  500.     } // El Brutalo colours 0 through 15
  501.     else {
  502.         for (i=0;i<NumColours;i++) {
  503.             if ((Pens[i] = ObtainPen(WBscreen->ViewPort.ColorMap,-1,0,0,0,PEN_EXCLUSIVE)) == -1) break;
  504.             if (Pens[i] > maxPen) maxPen = Pens[i];
  505.         }
  506.         if (i != NumColours) {
  507.             NumColours = i;
  508.             GFX_Off();
  509.             //NOGFXPOS = TRUE;
  510.             EasyRequest(act_w_hdl,&NoPens,NULL,NULL);
  511.             return;
  512.         }
  513.         if (!LDP) planesN = CountPlanes(maxPen);
  514.         //printf("Planes, Cols, Scrn: %d,%d,%d\n",planesN,NumColours,WBscreen->RastPort.BitMap->Depth);
  515.     }
  516.  
  517.     if (LDP) {
  518.         for (i=0; i<NumColours; i++) { //maybe check for NumColours == 8 should be done
  519.             CR[i].red = fgetc(gfx_in_file)>>4;
  520.             CR[i].green = fgetc(gfx_in_file)>>4;
  521.             CR[i].blue = fgetc(gfx_in_file)>>4;
  522.             //printf("LDP-Pen%2d: %3d %3d %3d\n",i+4,CR[i].red,CR[i].green,CR[i].blue);
  523.             if (FASTCOLOURS) SetRGB4(&WBscreen->ViewPort,i+4,CR[i].red,CR[i].green,CR[i].blue); //except syscolors 0-3
  524.             else SetRGB4(&WBscreen->ViewPort,Pens[i],CR[i].red,CR[i].green,CR[i].blue);
  525.         }
  526.         Rmem = (ULONG)AllocRaster(gfx_width+1,gfx_height+1);
  527.     }
  528.     else {
  529.         //if (GFXDOUBLE) fac = 2;
  530.         InitBitMap(&bitmapN,planesN,gfx_width,gfx_height);
  531.         for (i=0; i<planesN; i++) {
  532.             if ((bitmapN.Planes[i] = (PLANEPTR) AllocRaster(gfx_width,gfx_height)) == NULL) {
  533.                 planesN = i;
  534.                 GFX_Off();
  535.                 //NOGFXPOS = TRUE;
  536.                 EasyRequest(act_w_hdl,&NoGFX,NULL,"Non posso allocare la bitmap.\nGFX sarà esclusa.");
  537.                 return;
  538.             }
  539.         }
  540.         picture = (UBYTE *) MemAlloc(gfx_width * gfx_height);
  541.         rle_dat = (UBYTE *) MemAlloc(gfx_width * gfx_height);
  542.         overlay = (UBYTE *) MemAlloc(gfx_width * gfx_height);
  543.     }
  544.     //INIT = TRUE;
  545. }
  546. ///
  547.  
  548.  
  549. ///Speak
  550. void Speak(char *original)
  551. {
  552.     LONG tlres;
  553.  
  554.     if (SPEECH) {
  555.         if ((tlres = Translate((STRPTR) original,strlen(original),(STRPTR)nartrans,narBuf)) == 0) {
  556.             //printf("Speaking: %d: |%s|\n%d: |%s|\n",tlres,original,strlen(nartrans),nartrans);
  557.             request->message.io_Length = 1024;
  558.             DoIO((struct IORequest*)request);
  559.             //Delay(50);
  560.         }
  561.     }
  562. }
  563. ///
  564.  
  565.  
  566. /// Get_FileList
  567. /*
  568. void Get_FileList(char *dir, char **dfile_names, BYTE *cnt, BYTE mode)
  569. {
  570.     BPTR    dir_lock;
  571.     struct  FileInfoBlock *dfib;
  572.     APTR    pat;
  573.     char    dname[256];
  574.     static  BYTE cc = 0;
  575.  
  576.     if ((dir_lock = Lock(dir,SHARED_LOCK))) {
  577.         if ((dfib = (struct FileInfoBlock *) AllocDosObject(DOS_FIB,NULL))) {
  578.             if (Examine(dir_lock,dfib)) {
  579.                 pat = MemAlloc(12);
  580.                 ParsePatternNoCase("#?.dat",pat,12);
  581.                 while(ExNext(dir_lock,dfib)) {
  582.                     if (dfib->fib_DirEntryType == ST_USERDIR) {
  583.                         strcpy(dname,dir);
  584.                         AddPart(dname,dfib->fib_FileName,256);
  585.                         switch (mode) {
  586.                           case 0:
  587.                             Get_FileList(dname,NULL,cnt,0);
  588.                             break;
  589.                           case 1:
  590.                             Get_FileList(dname,dfile_names,NULL,1);
  591.                             break;
  592.                           default:
  593.                             break;
  594.                         }
  595.                     }
  596.                     if (dfib->fib_DirEntryType == ST_FILE && MatchPatternNoCase(pat,dfib->fib_FileName)) {
  597.                         switch (mode) {
  598.                           case 0:
  599.                             (*cnt)++;
  600.                             break;
  601.                           case 1:
  602.                             Make_FFP(dfib->fib_FileName,dir);
  603.                             dfile_names[cc++] = dyn_strings(FFP,0);
  604.                             break;
  605.                           default:
  606.                             break;
  607.                         }
  608.                     }
  609.                 }
  610.                 free(pat);
  611.             }
  612.             FreeDosObject(DOS_FIB,dfib);
  613.         }
  614.         UnLock(dir_lock);
  615.     }
  616. }*/
  617. ///
  618.  
  619. ///Open_ASL
  620. BOOL Open_ASL(char *file_name, char *dir_name, UBYTE mode)
  621. {
  622.    struct TagItem *ASLTags;
  623.    struct FileRequester *FileRequester;
  624.    LONG   areq;
  625.  
  626.    FileRequester = (struct FileRequester *) AllocAslRequest(ASL_FileRequest,NULL);
  627.    if (FileRequester == NULL) return(FALSE);
  628.    ASLTags = (struct TagItem *) AllocateTagItems(8);
  629.    if (ASLTags == NULL) {
  630.            FreeFileRequest(FileRequester);
  631.            return(FALSE);
  632.    }
  633.    ASLTags[0].ti_Tag = ASLFR_InitialPattern;
  634.    ASLTags[0].ti_Data = (ULONG) "#?.save";
  635.    if (mode == 2) ASLTags[0].ti_Data = (ULONG) "#?.dat";
  636.    ASLTags[1].ti_Tag = ASLFR_Flags1;
  637.    ASLTags[1].ti_Data = FRF_DOPATTERNS;
  638.    if (mode == 1) ASLTags[1].ti_Data = FRF_DOPATTERNS|FRF_DOSAVEMODE;
  639.    ASLTags[2].ti_Tag = ASLFR_TitleText; // 0: Restore Game, 1: Save Game, 2: Choose Adventure
  640.    ASLTags[2].ti_Data = (ULONG) "Ricarica gioco memorizzato";
  641.    if (mode == 1) ASLTags[2].ti_Data = (ULONG) "Memorizza gioco come ...";
  642.    if (mode == 2) ASLTags[2].ti_Data = (ULONG) "Scegli il data file Avventura";
  643.    ASLTags[3].ti_Tag = ASLFR_InitialFile;
  644.    ASLTags[3].ti_Data = (ULONG) file_name;
  645.    ASLTags[4].ti_Tag = ASLFR_InitialDrawer;
  646.    ASLTags[4].ti_Data = (ULONG) dir_name;
  647.    ASLTags[5].ti_Tag = ASLFR_PositiveText; // 0: Restore Game, 1: Save Game, 2: Choose Adventure
  648.    ASLTags[5].ti_Data = (ULONG) "Carica";
  649.    if (mode == 1) ASLTags[5].ti_Data = (ULONG) "Memorizza";
  650.    if (mode == 2) ASLTags[5].ti_Data = (ULONG) "Gioca";
  651.    ASLTags[6].ti_Tag = ASLFR_Window;
  652.    ASLTags[6].ti_Data = (ULONG) act_w_hdl;
  653.    ASLTags[7].ti_Tag = TAG_DONE;
  654.    if ((areq = AslRequest(FileRequester,ASLTags))) {
  655.                 strcpy(file_name,FileRequester->fr_File);
  656.                 strcpy(dir_name,FileRequester->fr_Drawer);
  657.                 //printf("Dir, File: %s, %s\n",FileRequester->fr_File,FileRequester->fr_Drawer);
  658.    }
  659.    FreeTagItems(ASLTags);
  660.    FreeFileRequest(FileRequester);
  661.    if (areq) return(TRUE);
  662.    return(FALSE); // Cancel pressed or ASL-problem
  663. }///
  664.  
  665. /// Get_FileSize
  666. /*
  667. LONG Get_FileSize(BPTR file_lock)
  668. {
  669.         struct  FileInfoBlock *ffib;
  670.  
  671.         if ((ffib = (struct FileInfoBlock *) AllocDosObject(DOS_FIB,NULL))) {
  672.                 if (Examine(file_lock,ffib)) {
  673.                         printf("Nome: %s\nDimensione: %d\n",ffib->fib_FileName,ffib->fib_Size);
  674.                 }
  675.                 FreeDosObject(DOS_FIB,ffib);
  676.                 return(ffib->fib_Size);
  677.         }
  678.         return(0);
  679. } */
  680. ///
  681.  
  682. /// Show_FileList
  683. /*
  684. void Show_FileList(char *dir)
  685. {
  686.         char **dfile_names;
  687.         BYTE i,cnt = 0;
  688.  
  689.         Get_FileList(dir,NULL,&cnt,0);
  690.         dfile_names = (char **) MemAlloc(sizeof(char *) * cnt);
  691.         Get_FileList(dir,dfile_names,NULL,1);
  692.         for (i=0;i<=cnt-1;i++) {
  693.                 printf("%2d: %10.*s [%s]\n",i,(int)strlen(FilePart(dfile_names[i]))-4,FilePart(dfile_names[i]),dfile_names[i]);
  694.         }
  695.         if (cnt > 0) for (i=0;i<=cnt-1;i++) free(dfile_names[cnt]);
  696.         free(dfile_names);
  697. }*/
  698. ///
  699.  
  700. /// Open_File
  701. FILE * Open_File(char * file_name)
  702. {
  703.     FILE    *f;
  704.  
  705.     if ((f = fopen(file_name,"r")) == NULL) {
  706.         perror(file_name);
  707.         EasyRequest(NULL,&FError,NULL,file_name);
  708.         close_libs();
  709.         exit(1);
  710.     }
  711.     strcat(restart_file,(char *)FilePart(file_name));
  712.     strcat(restart_file,".res");
  713.     return(f);
  714. }///
  715.  
  716. /// Get_AdvFile
  717. FILE * Get_AdvFile(char *data_file, char *data_dir)
  718. {
  719.     BPTR    lock;
  720.  
  721.     if (strcmp(data_file,"") == 0) strcpy(data_file,".dat");
  722.     Make_FFP(data_file,data_dir);
  723.     while ((lock = Lock(FFP,SHARED_LOCK)) == NULL) {
  724.         if (Open_ASL(data_file,data_dir,2) == FALSE) return(NULL);
  725.         //    close_all();
  726.         //    exit(64);
  727.         //}
  728.         Make_FFP(data_file,data_dir);
  729.     }
  730.     UnLock(lock);
  731.     return(Open_File(FFP));
  732. }///
  733.  
  734. ///Get_GFXSize
  735. void Get_GFXSize(void)
  736. {
  737.     gfx_in_file = fopen(gfx_file,"rb");
  738.     if (gfx_in_file == NULL) {
  739.         //printf("No GFX\n");
  740.         GFX = FALSE;
  741.         return;
  742.     }
  743.     // Fetch GFX size from binary file
  744.     gfx_width = fgetc(gfx_in_file)*256 + fgetc(gfx_in_file);
  745.     gfx_height = fgetc(gfx_in_file)*256 + fgetc(gfx_in_file);
  746.     //printf("GFX-Size: %d x %d Pixel.\n",gfx_width,gfx_height);
  747.  
  748. }///
  749.  
  750. ///Get_PicLog
  751. void Get_PicLog(void)
  752. {
  753.     int           i,j = 0,k,kk,rnum,count,nac89;
  754.     unsigned char in_dat[1024];
  755.  
  756.     nroom = fgetc(gfx_in_file); // Number of rooms (maybe +1 if showPIC starts with 0 and not 1 !!!)
  757.     nac89 = fgetc(gfx_in_file); // Number of Action89 pics
  758.     fgetc(gfx_in_file); // Number of extended room pics
  759.     
  760.     // Read pic offset in bytes/room
  761.     count = fgetc(gfx_in_file);
  762.     //printf("\n%d Offsets\n",count);
  763.     //if (count != npics) printf("Serio problema in gfx file\n. Aspettati un GURU :-)\n");
  764.     //printf("Speicher1: %ld\n",*go);
  765.     go = malloc(sizeof(unsigned long)  * count);
  766.     //printf("Speicher2: %ld\n",*go);
  767.     fread(&in_dat[0],1,count*3,gfx_in_file);
  768.     for (i=0; i<count; i++) {
  769.         go[i] = (unsigned long) in_dat[i*3]*256*256 + (unsigned long) in_dat[i*3+1]*256 + in_dat[i*3+2];
  770.         //printf("GFX-OFF%d: %7ld\n",i,go[i]);
  771.     }
  772.     if (go[0] == 0) LDP = TRUE; //use darkness pic offset as LDP Flag
  773.     else LDP = FALSE;
  774.     //printf("Offset0/LDP: %d/%d\n",go[0],LDP);
  775.     rp = malloc(sizeof(room_pics) * (nroom+nac89+1)); //pic0 is black (darkness)
  776.     for (i=0; i<=nroom+nac89; i++) rp[i].ppr = 0;
  777.  
  778.     count = fgetc(gfx_in_file)*256 + fgetc(gfx_in_file); // how many BYTES!!! for room logic
  779.     //printf("%d Logic Bytes\n",count);
  780.     fread(&in_dat[0],1,count,gfx_in_file);
  781.     while (j<count) {
  782.         rnum = in_dat[j++];
  783.         rp[rnum].ppr = in_dat[j++];
  784.         if (rp[rnum].ppr > MAX_PPR) { // Byte 2: How many pics/room (except default pic)
  785.             GFX_Off();
  786.             EasyRequest(act_w_hdl,&NoGFX,NULL,"GFX datafile corrotto\o errato datafile (PPR).\nGFX sarà esclusa.");
  787.             return;
  788.         }
  789.         //printf("\nRoom: %2d (%2d Pics)\n ",rnum,rp[rnum].ppr);
  790.         for (i=0; i<rp[rnum].ppr; i++) {
  791.             rp[rnum].what[i] = in_dat[j++];
  792.             kk = rp[rnum].what[i]-80;
  793.             while (kk < 0) kk += 10;
  794.             if (kk > MAX_LOG) {
  795.                 GFX_Off();
  796.                 EasyRequest(act_w_hdl,&NoGFX,NULL,"GFX datafile corrotto\o errato datafile (LOG).\nGFX sarà esclusa.");
  797.                 return;
  798.             }
  799.             for (k=0; k<kk; k++) {
  800.                 rp[rnum].loc[i][k] = in_dat[j++];
  801.                 rp[rnum].obj[i][k] = in_dat[j++];
  802.                 //printf("Ob%d|%d: %2d,Loc%d: %d - ",i,k,rp[rnum].obj[i][k],i,rp[rnum].loc[i][k]);
  803.             }
  804.             rp[rnum].pnr[i] = in_dat[j++]; // picture number to display if condition is TRUE
  805.         }
  806.     }
  807.     //close_all();
  808.     //exit(0);
  809. }
  810. ///
  811.  
  812. /// Init_Win
  813. void Init_Win(struct FileHandle *win, BYTE fg, BYTE bg)
  814. {
  815.         CON_handle = win;
  816.         clrsys();
  817.         background(bg);
  818.         textcolor(fg,bg);
  819.         cursor(FALSE);
  820. }///
  821.  
  822. /// Open_Wins
  823. void Open_Wins(UWORD fy_size, char **font_name, char *cscreen)
  824. {
  825.         WORD    w_height_gfx,w_height_env,w_height_act,w_width,w_left;
  826.         UWORD   fx_size;
  827.         struct  Screen *DefPubScr;
  828.         //char    DefPubScrName[256];
  829.  
  830.         if (fy_size) Get_Font(fy_size,*font_name);
  831.         //free(*font_name);Betori vengono deallocate in chiusura
  832.         //free(font_name);Betori
  833.         if (textfont) fx_size = (UWORD) textfont->tf_XSize;
  834.         else {
  835.             DefPubScr = (struct Screen *) LockPubScreen("Workbench");
  836.             fx_size = DefPubScr->FirstWindow->IFont->tf_XSize;
  837.             fy_size = DefPubScr->FirstWindow->IFont->tf_YSize;
  838.             //printf("X: %d, Y: %d (%s)\n",fx_size,fy_size,DefPubScr->FirstWindow->IFont->tf_Message.mn_Node.ln_Name);
  839.             if (DefPubScr) UnlockPubScreen("Workbench",NULL);
  840.         }
  841.         w_width = (WORD) (Width * fx_size + /*(BYTE)*/ WBscreen->WBorLeft + /*(BYTE)*/ WBscreen->WBorRight);
  842.         w_height_env = (WORD) (TopHeight * fy_size + /*(BYTE)*/ WBscreen->WBorTop + WBscreen->Font->ta_YSize + WBscreen->WBorBottom + 1);
  843.         w_height_act = (WORD) (BottomHeight * fy_size + /*(BYTE)*/ WBscreen->WBorTop + WBscreen->Font->ta_YSize + WBscreen->WBorBottom + 2);
  844.         w_height_gfx = (WORD) (gfx_height + /*(BYTE)*/ WBscreen->WBorTop + WBscreen->Font->ta_YSize + WBscreen->WBorBottom + 1);
  845.         w_left = (WORD) (WBscreen->Width - w_width) / 2;
  846.         w_top = (WORD) (WBscreen->Height - w_height_env - w_height_act - w_height_gfx) / 2 + w_height_gfx;
  847.         if ((w_top + w_height_env + w_height_act) > WBscreen->Height) w_top = WBscreen->Height - w_height_env - w_height_act;
  848.         if ((w_width > WBscreen->Width) || ((w_height_env+w_height_act) > WBscreen->Height)) {
  849.             EasyRequest(NULL,&BigWins,NULL,NULL);
  850.             close_all();
  851.             exit(20);
  852.         }
  853.         env_hdl = Open_CON("RAW",w_left,w_top,w_width,w_height_env,"Ambiente","NOSIZE",cscreen);
  854.         act_hdl = Open_CON("CON",w_left,w_top+w_height_env,w_width,w_height_act,"SCOTT-Free AMIGA","NOSIZE",cscreen);
  855.         Set_NewFont();
  856.         Init_Win(env_hdl,WHITE,BLUE);
  857.         Init_Win(act_hdl,BLACK,GREY);
  858.         scott_guide.nag_Screen = act_w_hdl->WScreen;
  859.         OldUserPort = act_w_hdl->UserPort;
  860.         act_w_hdl->UserPort = 0;
  861.         ModifyIDCMP(act_w_hdl,MENUPICK|RAWKEY|VANILLAKEY|CLOSEWINDOW|NEWSIZE);
  862.         menu = (struct Menu *) CreateMenus(newmenu,TAG_DONE);
  863.         LayoutMenus(menu,WBvisinfo,TAG_DONE);
  864.         SetMenuStrip(act_w_hdl,menu);
  865. }///
  866.  
  867. /// Size_Wins
  868. void Size_Wins(BOOL tandy)
  869. {
  870.         if (tandy) {
  871.                 Width = 64;
  872.                 TopHeight = 11;
  873.                 BottomHeight = 13;
  874.                 Options|=TRS80_STYLE;
  875.         }
  876.         else {
  877.                 if (Width == 0) Width = 80;
  878.                 TopHeight = 10;
  879.                 BottomHeight = 15;
  880.         }
  881. }///
  882.  
  883. /// copyright
  884. void copyright(void)
  885. {
  886.     OutReset();
  887.     OutBuf("AMIGA SCOTT-Free v1.92 italiana, di Betori Alessandro\n");
  888.     Speak("AMIGA SCOTT-Free versione 1.92 italiana, di Betori Alessandro");
  889.     OutBuf("Basata su SCOTT-Free Amiga v1.91 inglese,\n\n © Andreas Aumayr, anden@gmx.at\n\n");
  890.     Speak("Basata su SCOTT-Free Amiga versione inglese 1.91, copyright Andreas Aumayr, anden at g m x point a t");
  891.     OutBuf("Basata su SCOTT-Free UNIX/DOS v1.14b, © Alan Cox\n\n");
  892.     Speak("Basata su SCOTT-Free UNIX/DOS versione 1.14b, copyright Alan Cox");
  893. }///
  894.  
  895. /// FirstOfAll
  896. void FirstOfAll(FILE *f)
  897. {
  898.     copyright();
  899.     OutBuf("Caricamento avventura data file ...  ");
  900.     Speak("Caricamento avventura data file");
  901.     LoadDatabase(f,(Options&DEBUGGING)?1:0);
  902.     fclose(f);
  903.     OutBuf("Finito.\n\n");
  904.     Speak("Finito.");
  905.     if (SaveRestart()) {
  906.         OffMenu(act_w_hdl,63649);
  907.         RESTART = FALSE;
  908.     }
  909. } ///
  910.  
  911. /// Restart
  912. void Restart(void)
  913. {
  914.     WriteCON(CLRSCR);
  915.     BitFlags = 0;
  916.     LoadRestart();
  917.     WriteCON("Ricomincio ...\n\n");
  918.     Speak("Ricomincio.");
  919.     Delay(20);
  920.     copyright();
  921.     PerformActions(0,0);
  922.     Look();
  923.     //strcpy(command,"");
  924. } ///
  925.  
  926. /// Init
  927. void Init(char *prog_name, char *adv_file, char *save_file)
  928. {
  929.     UWORD   fy_size = 0;
  930.     FILE    *f;  
  931.     font_name = (char **) MemAlloc(sizeof(char *));
  932.     cscreen = (char **) MemAlloc(sizeof(char *));
  933.  
  934.  
  935.     if (open_libs() == FALSE) {
  936.         close_libs();
  937.         exit(255);
  938.     }
  939.  
  940.     Size_Wins(Get_TT(prog_name,&fy_size,font_name,data_file,data_dir,cscreen));
  941.     if (Options & TRS80_STYLE) Size_Wins(TRUE);
  942.  
  943.     old_pubmode = SetPubScreenModes(POPPUBSCREEN);
  944.  
  945.     if (strcmp(adv_file,"") != NULL) {
  946.         strcpy(data_file,adv_file);
  947.         strcat(data_file,".dat");
  948.         f = Open_File(data_file);
  949.         strcat(strncpy(gfx_file,data_file,strlen(data_file)-4),".gfx");
  950.     }
  951.     else {
  952.         strcat(data_file,".dat");
  953.         if ((f = Get_AdvFile(data_file,data_dir)) == NULL) {
  954.             close_all();
  955.             exit(64);
  956.         }
  957.         strcat(strncpy(gfx_file,data_file,strlen(data_file)-4),".gfx");
  958.         Make_FFP(gfx_file,data_dir);
  959.         strcpy(gfx_file,FFP);
  960.     }
  961.     //printf("\n%s (%s - %s)\n",gfx_file,data_file,data_dir);
  962.  
  963.     if (Disp_ID) {
  964.         WORD D3Pens[] = {-1};
  965.         ScottScreen = (struct Screen *) OpenScreenTags(0,SA_Pens,D3Pens,SA_Depth,4,SA_DisplayID,Disp_ID,
  966.         SA_Type,PUBLICSCREEN,SA_Overscan,OSCAN_TEXT,SA_Title,"SCOTT-Free",SA_SysFont,1,
  967.         SA_PubName,"SCOTT-Free", SA_PubSig,0,SA_PubTask,NULL,TAG_DONE);
  968.         //SA_Interleaved,1, --> V39+
  969.         if (ScottScreen) {
  970.             PubScreenStatus(ScottScreen,0);
  971.             //if (*cscreen) FreeMem(*cscreen,sizeof(cscreen));
  972.             *cscreen = dyn_strings("SCOTT-Free",0);
  973.         }
  974.         else EasyRequest(NULL,&NoScreen,NULL,NULL);
  975.     }
  976.  
  977.     if ((WBscreen = (struct Screen *) LockPubScreen(*cscreen)) == NULL) WBscreen = (struct Screen *) LockPubScreen("Workbench");
  978.     if (WBscreen) {
  979.         if ((WBvisinfo  = (APTR) GetVisualInfo(WBscreen,NULL))) {
  980.             
  981.             //Show_FileList(data_dir);
  982.             
  983.             Get_GFXSize();
  984.  
  985.             //if ((WBscreen->Width / WBscreen->Height) > 1) GFXDOUBLE = TRUE;
  986.  
  987.             Open_Wins(fy_size,font_name,*cscreen);
  988.  
  989.             //if (*cscreen) FreeMem(*cscreen,sizeof(*cscreen));
  990.             //FreeMem(cscreen,sizeof(cscreen));
  991.             
  992.             if (GFX) Get_PicLog();
  993.             else OffMenu(act_w_hdl,63491);
  994.             if (GFX) Init_GFX();
  995.  
  996.             if (TranslatorBase) {
  997.                 narBuf = sizeof(nartrans);
  998.                 request->message.io_Message.mn_ReplyPort = narratorPort;
  999.                 request->message.io_Command = CMD_WRITE;
  1000.                 request->message.io_Data = (APTR) nartrans;
  1001.                 request->rate = 160;
  1002.                 request->pitch = DEFPITCH;
  1003.                 request->sex = FEMALE;
  1004.                 request->ch_masks = channels;
  1005.                 request->nm_masks = sizeof(channels);
  1006.                 request->volume = 64;
  1007.             }
  1008.             else OffMenu(act_w_hdl,63523);
  1009.             if (SPEECH) ((struct MenuItem *) ItemAddress(menu,63523))->Flags |= CHECKED;
  1010.  
  1011.             FirstOfAll(f);
  1012.  
  1013.             if (strcmp(save_file,"") != NULL) LoadGame(save_file);
  1014.             else if (strcmp(save_game,"") != NULL) {
  1015.                 Make_FFP(save_game,save_dir);
  1016.                 LoadGame(FFP);
  1017.             }
  1018.             else {
  1019.                 strncpy(save_game,data_file,strlen(data_file)-4);
  1020.                 strcat(save_game,".save");
  1021.             }
  1022.  
  1023.             if (AmigaGuideBase) scott_guide.nag_Name = "Scott.guide";
  1024.  
  1025.             return;
  1026.         }
  1027.         printf("\nProblemi nel prendere informazioni visuali per lo schermo '%s'!\n",*cscreen);
  1028.         close_all();
  1029.     }
  1030.     printf("\nProblemi nel lock del custom screen '%s'\n",*cscreen);
  1031.     close_libs();
  1032. }///
  1033.  
  1034. /// NewGame
  1035. BOOL NewGame(void)
  1036. {
  1037.     FILE    *f;
  1038.  
  1039.     strcpy(data_file,".dat");
  1040.     if ((f = Get_AdvFile(data_file,data_dir)) == NULL) return(FALSE);
  1041.     strncpy(gfx_file,data_file,strlen(data_file)-4);
  1042.     gfx_file[strlen(data_file)-4] = 0;
  1043.     strcat(gfx_file,".gfx");
  1044.     Make_FFP(gfx_file,data_dir);
  1045.     strcpy(gfx_file,FFP);
  1046.     //printf("%s\n",gfx_file);
  1047.  
  1048.     if (restart_lock) UnLock(restart_lock);
  1049.     DeleteFile(restart_file);
  1050.  
  1051.     if (GFX) {
  1052.         if (pic_w_hdl) {
  1053.             CloseWindow(pic_w_hdl);
  1054.             pic_w_hdl = 0;
  1055.         }
  1056.         FreeGFXRes();
  1057.     }
  1058.  
  1059.     //printf("Get New GFX File\n");
  1060.     GFX = TRUE;
  1061.     OnMenu(act_w_hdl,63491);
  1062.     Get_GFXSize();
  1063.     if (!GFX) OffMenu(act_w_hdl,63491);
  1064.     else Get_PicLog();
  1065.     if (GFX) Init_GFX();
  1066.  
  1067.     BitFlags = 0;
  1068.     strcpy(GameInfoStr,"");
  1069.  
  1070.     WriteCON(CLRSCR);
  1071.     FirstOfAll(f);
  1072.  
  1073.     strncpy(save_game,data_file,strlen(data_file)-4);
  1074.     save_game[strlen(data_file)-4] = 0;
  1075.     strcat(save_game,".save");
  1076.     //printf("%s\n",save_game);
  1077.  
  1078.     srand(time(NULL));
  1079.     return(TRUE);
  1080. }///
  1081.  
  1082. /// Menu_Handle
  1083. BOOL Menu_Handle(int code, char *command)
  1084. {
  1085.     //strcpy(command,"");
  1086.     //printf("Packed, Menu, Item, SubItem, Address: %d, %d, %d, %d, %d\n",code,MENUNUM(code),ITEMNUM(code),SUBNUM(code),(struct MenuItem *) ItemAddress(menu,code));
  1087.     if (MENUNUM(code) != MENUNULL) {
  1088.         switch(MENUNUM(code)) {
  1089.             case 0:
  1090.                 switch(ITEMNUM(code)) {
  1091.                     case 0:
  1092.                         EasyRequest(act_w_hdl,&About,NULL,NULL);
  1093.                         return(FALSE);
  1094.                         break;
  1095.                     case 2:
  1096.                         if (NewGame()) {
  1097.                             PerformActions(0,0);
  1098.                             Look();
  1099.                             strcpy(command,"");
  1100.                             return(TRUE);
  1101.                         }
  1102.                         else return(FALSE);
  1103.                         break;
  1104.                     case 4:
  1105.                         if (AmigaGuideBase) {
  1106.                             CloseAmigaGuide(OpenAmigaGuide(&scott_guide,NULL));
  1107.                         }
  1108.                         return(FALSE);
  1109.                         break;
  1110.                     case 6:
  1111.                         if (EasyRequest(act_w_hdl,&Quit,NULL,"")) {
  1112.                             close_all();
  1113.                             exit(0);
  1114.                         }
  1115.                         return(FALSE);
  1116.                         break;
  1117.                 }
  1118.                 break;
  1119.             case 1:
  1120.                 switch(ITEMNUM(code)) {
  1121.                     case 0:
  1122.                         EasyRequest(act_w_hdl,&GameInfo,NULL,GameInfoStr);
  1123.                         return(FALSE);
  1124.                         break;
  1125.                     case 2:
  1126.                         strcpy(command,"!RICARICA");
  1127.                         WriteCON("!RICARICA\n");
  1128.                         return(TRUE);
  1129.                         break;
  1130.                     case 3:
  1131.                         strcpy(command,"MEMORIZZA GIOCO");
  1132.                         WriteCON("MEMORIZZA GIOCO\n");
  1133.                         return(TRUE);
  1134.                         break;
  1135.                     case 5:
  1136.                         Restart();
  1137.                         strcpy(command,"");
  1138.                         return(TRUE);
  1139.                         break;
  1140.                 }
  1141.                 break;
  1142.             case 2:
  1143.                 switch(ITEMNUM(code)) {
  1144.                     case 0:
  1145.                         strcpy(command,"GUARDA");
  1146.                         WriteCON("GUARDA\n");
  1147.                         return(TRUE);
  1148.                         break;
  1149.                     case 1:
  1150.                         strcpy(command,"INVENTARIO");
  1151.                         WriteCON("INVENTARIO\n");
  1152.                         return(TRUE);
  1153.                         break;
  1154.                     case 2:
  1155.                         strcpy(command,"PRENDI TUTTO");
  1156.                         WriteCON("PRENDI TUTTO\n");
  1157.                         return(TRUE);
  1158.                         break;
  1159.                     case 4:
  1160.                         strcpy(command,"PUNTEGGIO");
  1161.                         WriteCON("PUNTEGGIO\n");
  1162.                         return(TRUE);
  1163.                         break;
  1164.                 }
  1165.                 break;
  1166.             case 3:
  1167.                 switch(ITEMNUM(code)) {
  1168.                     case 0:
  1169.                         GFX = (GFX)?FALSE:TRUE;
  1170.                         if (GFX == FALSE) {
  1171.                             WriteCON("\n- La grafica è esclusa ora.\nCosa devo fare ? ");
  1172.  
  1173.                             if (pic_w_hdl) {
  1174.                                 win_pos_ver = pic_w_hdl->LeftEdge;
  1175.                                 win_pos_hor = pic_w_hdl->TopEdge;
  1176.                                 CloseWindow(pic_w_hdl);
  1177.                                 pic_w_hdl = 0;
  1178.                             }
  1179.                         }
  1180.                         else {
  1181.                             WriteCON("\n- La grafica è attiva ora.\nCosa devo fare ? ");
  1182.                             last_pic = -128;
  1183.                             Look();
  1184.                         }
  1185.                         return(FALSE);
  1186.                         break;
  1187.                     case 1:
  1188.                         SPEECH = (SPEECH)?FALSE:TRUE;
  1189.                         if (SPEECH == FALSE) WriteCON("\n- Il parlato è disattivato ora.\nCosa devo fare ? ");
  1190.                         else {
  1191.                             WriteCON("\n- Il parlato è attivo ora.\nCosa devo fare ? ");
  1192.                             Speak("Il parlato è attivo ora.\nCosa devo fare ? ");
  1193.                         }
  1194.                         return(FALSE);
  1195.                         break;
  1196.                 }
  1197.         }
  1198.     }
  1199.     return(FALSE);
  1200. }///
  1201.  
  1202. /// LineInput2
  1203. void LineInput2(char *command)
  1204. {
  1205.     UWORD       code,qual;
  1206.     ULONG       class;
  1207.     struct      IntuiMessage *mess;
  1208.     char        buf[MAX_LL+1],ncom[MAX_LL+1];
  1209.     int         len=0,c_pos=0,h_pos;
  1210.  
  1211.     h_pos = hist_pos;
  1212.     do {
  1213.         WaitPort(act_w_hdl->UserPort);
  1214.         while ((mess = (struct IntuiMessage *) GT_GetIMsg(act_w_hdl->UserPort))) {
  1215.             class = mess->Class;
  1216.             code  = mess->Code;
  1217.             qual  = mess->Qualifier;
  1218.             GT_ReplyIMsg(mess);
  1219.             switch (class) {
  1220.                 case IDCMP_VANILLAKEY:
  1221.                     if ((code >=32) && (code <=126)) {
  1222.                         if (len < MAX_LL) {
  1223.                             if (len != c_pos) {
  1224.                                 strcpy(buf,&hist[hist_pos][c_pos]);
  1225.                                 hist[hist_pos][c_pos] = code;
  1226.                                 hist[hist_pos][c_pos+1] = 0;
  1227.                                 strcat(&hist[hist_pos][0],buf);
  1228.                                 sprintf(buf,"%s%c",INS_CHAR,code);
  1229.                                 WriteCON(buf);
  1230.                             }
  1231.                             else {
  1232.                                 hist[hist_pos][c_pos] = code;
  1233.                                 sprintf(buf,"%c",code);
  1234.                                 WriteCON(buf);
  1235.                             }
  1236.                             len++;
  1237.                             c_pos++;
  1238.                         }
  1239.                         break;
  1240.                     }
  1241.                     switch (code) {
  1242.                         case 8: //Backspace
  1243.                             if (c_pos > 0) {
  1244.                                 WriteCON(CURSOR_LEFT);
  1245.                                 WriteCON(DEL_CHAR);
  1246.                                 if (len != c_pos) {
  1247.                                     strcpy(buf,&hist[hist_pos][c_pos]);
  1248.                                     hist[hist_pos][c_pos-1] = 0;
  1249.                                     strcat(&hist[hist_pos][0],buf);
  1250.                                 }
  1251.                                 c_pos--;
  1252.                                 len--;
  1253.                             }
  1254.                             break;
  1255.                         case 27: //Escape
  1256.                             c_pos = len = 0;
  1257.                             strcpy(ncom,"");
  1258.                             gotoxy(18,BottomHeight);
  1259.                             WriteCON(CLREOL);
  1260.                             break;
  1261.                         case 127: //Delete
  1262.                             if (c_pos < len) {
  1263.                                 WriteCON(DEL_CHAR);
  1264.                                 if (len != c_pos+1) {
  1265.                                     strcpy(buf,&hist[hist_pos][c_pos+1]);
  1266.                                     hist[hist_pos][c_pos] = 0;
  1267.                                     strcat(&hist[hist_pos][0],buf);
  1268.                                 }
  1269.                                 len--;
  1270.                             }
  1271.                             break;
  1272.                     }
  1273.  
  1274.                 case IDCMP_RAWKEY:
  1275.                     switch (code) {
  1276.                         case 10:
  1277.                         case 13:
  1278.                             hist[hist_pos][len] = 0;
  1279.                             strcpy(command,&hist[hist_pos][0]);
  1280.                             hist_pos++;
  1281.                             if (hist_pos >= MAX_HIST) hist_pos = 0;
  1282.                             if (hist_fill < MAX_HIST-1) hist_fill++;
  1283.                             WriteCON("\n");
  1284.                             return;
  1285.                             break;
  1286.                         case 76:
  1287.                             h_pos--;
  1288.                             if (h_pos < 0) h_pos = hist_fill;
  1289.                             if (h_pos != hist_pos) strcpy(ncom,&hist[h_pos][0]);
  1290.                             else strcpy(ncom,"");
  1291.                             c_pos = len = strlen(ncom);
  1292.                             gotoxy(18,BottomHeight);
  1293.                             sprintf(buf,"%s%s",CLREOL,ncom);
  1294.                             WriteCON(buf);
  1295.                             strcpy(&hist[hist_pos][0],ncom);
  1296.                             break;
  1297.                         case 77:
  1298.                             h_pos++;
  1299.                             if (h_pos > hist_fill) h_pos = 0;
  1300.                             if (h_pos != hist_pos) strcpy(ncom,&hist[h_pos][0]);
  1301.                             else strcpy(ncom,"");
  1302.                             c_pos = len = strlen(ncom);
  1303.                             gotoxy(18,BottomHeight);
  1304.                             sprintf(buf,"%s%s",CLREOL,ncom);
  1305.                             WriteCON(buf);
  1306.                             strcpy(&hist[hist_pos][0],ncom);
  1307.                             break;
  1308.                         case 78:
  1309.                             if ((qual & IEQUALIFIER_LSHIFT) || (qual & IEQUALIFIER_RSHIFT)) {
  1310.                                 c_pos = len;
  1311.                                 gotoxy(18+len,BottomHeight);
  1312.                             }
  1313.                             else if (c_pos < len) {
  1314.                                 WriteCON(CURSOR_RIGHT);
  1315.                                 c_pos++;
  1316.                             }
  1317.                             break;
  1318.                         case 79:
  1319.                             if ((qual & IEQUALIFIER_LSHIFT) || (qual & IEQUALIFIER_RSHIFT)) {
  1320.                                 c_pos = 0;
  1321.                                 gotoxy(18,BottomHeight);
  1322.                             }
  1323.                             else if (c_pos > 0) {
  1324.                                 WriteCON(CURSOR_LEFT);
  1325.                                 c_pos--;
  1326.                             }
  1327.                             break;
  1328.                         case 95: //Help
  1329.                             if (AmigaGuideBase) {
  1330.                                 CloseAmigaGuide(OpenAmigaGuide(&scott_guide,NULL));
  1331.                             }
  1332.                             break;
  1333.                         default:
  1334.                             break;
  1335.                     }
  1336.                     break;
  1337.  
  1338.                 case IDCMP_MENUPICK:
  1339.                     if (Menu_Handle(code,command)) {
  1340.                         strcpy(&hist[hist_pos][0],command);
  1341.                         WriteCON(command);
  1342.                         hist_pos++;
  1343.                         if (hist_pos >= MAX_HIST) hist_pos = 0;
  1344.                         if (hist_fill < MAX_HIST-1) hist_fill++;
  1345.                         return;
  1346.                     }
  1347.                     break;
  1348.  
  1349.                 case IDCMP_CLOSEWINDOW:
  1350.                     if (EasyRequest(act_w_hdl,&Quit,NULL,NULL)) {
  1351.                         close_all();
  1352.                         exit(0);
  1353.                         return;
  1354.                     }
  1355.                     break;
  1356.             }
  1357.         }
  1358.     } while (1);
  1359. }///
  1360.  
  1361. ///KeyInput
  1362. USHORT KeyInput(void)
  1363. {
  1364.     USHORT      code;
  1365.     ULONG       class;
  1366.     struct      IntuiMessage *mess;
  1367.  
  1368.     do {
  1369.         WaitPort(act_w_hdl->UserPort);
  1370.         while ((mess = (struct IntuiMessage *) GT_GetIMsg(act_w_hdl->UserPort))) {
  1371.             class = mess->Class;
  1372.             code  = mess->Code;
  1373.             GT_ReplyIMsg(mess);
  1374.             switch (class) {
  1375.                 case IDCMP_VANILLAKEY:
  1376.                     if (((code >=32) && (code <=126)) || (code == 13)) return(code);
  1377.             }
  1378.         }
  1379.     } while (1);
  1380. }///
  1381.  
  1382.  
  1383.  
  1384.  
  1385.  
  1386.  
  1387. /// rle_decode
  1388. void rle_decode(int size)
  1389. {
  1390.     int j,i;
  1391.     int repeat,count;
  1392.  
  1393.     fread(&rle_dat[0],1,size,gfx_in_file);
  1394.     j = i = 0;
  1395.     while (j<size) {
  1396.         while (rle_dat[j] < 128) {
  1397.             picture[i++] = rle_dat[j++];
  1398.             if (j>=size) return;
  1399.         }
  1400.         repeat = rle_dat[j++]-128;
  1401.         for (count=0; count < repeat; count++) picture[i++] = rle_dat[j];
  1402.         j++;
  1403.     }
  1404. }///
  1405.  
  1406. /// rle_decodeOvl
  1407. void rle_decodeOvl(int size)
  1408. {
  1409.     int j,i;
  1410.     int repeat,count;
  1411.  
  1412.     fread(&rle_dat[0],1,size,gfx_in_file);
  1413.     j = i = 0;
  1414.     while (j<size) {
  1415.         while (rle_dat[j] < 128) {
  1416.             overlay[i++] = rle_dat[j++];
  1417.             if (j>=size) return;
  1418.         }
  1419.         repeat = rle_dat[j++]-128;
  1420.         for (count=0; count < repeat; count++) overlay[i++] = rle_dat[j];
  1421.         j++;
  1422.     }
  1423. }///
  1424.  
  1425. /// Pixel2BitmapFast
  1426. void Pixel2BitmapFast(void)
  1427. {
  1428.     int x,y,plane,byte,lbyte,pen;
  1429.     unsigned int lbit;
  1430.  
  1431.     for (plane=0; plane<planesN; plane++) BltClear(bitmapN.Planes[plane],RASSIZE(gfx_width,gfx_height),0);
  1432.     for (y = 0; y < gfx_height; y++) {
  1433.         lbyte = y * bitmapN.BytesPerRow;
  1434.         lbit = lbyte << 3;
  1435.         for (x = 0; x < gfx_width; x++) {
  1436.             pen = picture[lbit + x];
  1437.             byte = lbyte + (x>>3);
  1438.             for (plane = 0; plane < planesN; plane++) {
  1439.                 if (pen & (1<<plane)) *(bitmapN.Planes[plane] + byte) |= 128>>(x&7);
  1440.             }
  1441.         }
  1442.     }
  1443. }
  1444. ///
  1445.  
  1446. /*
  1447. /// Pixel2BitmapFastDouble
  1448. void Pixel2BitmapFastDouble(void)
  1449. {
  1450.     int x,y,plane,byte,lbyte,pen;
  1451.     unsigned int lbit;
  1452.  
  1453.     for (plane=0; plane<planesN; plane++) BltClear(bitmapN.Planes[plane],RASSIZE(gfx_width,gfx_height),0);
  1454.     for (y = 0; y < gfx_height; y++) {
  1455.         lbyte = y * bitmapN.BytesPerRow;
  1456.         lbit = lbyte << 3;
  1457.         for (x = 0; x < gfx_width; x++) {
  1458.             pen = picture[lbit + x];
  1459.             byte = lbyte + (x>>3);
  1460.             for (plane = 0; plane < planesN; plane++) {
  1461.                 if (pen & (1<<plane)) *(bitmapN.Planes[plane] + byte) |= 192>>((x<<2)&7);
  1462.             }
  1463.         }
  1464.     }
  1465. }
  1466. ///
  1467. */
  1468.  
  1469. /// Pixel2BitmapFastOvl
  1470. void Pixel2BitmapFastOvl(void)
  1471. {
  1472.     int x,y,plane,byte,lbyte,pen;
  1473.     unsigned int lbit;
  1474.  
  1475.     for (plane=0; plane<planesN; plane++) BltClear(bitmapN.Planes[plane],RASSIZE(gfx_width,gfx_height),0);
  1476.     for (y = 0; y < gfx_height; y++) {
  1477.         lbyte = y * bitmapN.BytesPerRow;
  1478.         lbit = lbyte << 3;
  1479.         for (x = 0; x < gfx_width; x++) {
  1480.             pen = overlay[lbit + x];
  1481.             if (pen > 15) pen = picture[lbit + x];
  1482.             byte = lbyte + (x>>3);
  1483.             for (plane = 0; plane < planesN; plane++) {
  1484.                 if (pen & (1<<plane)) *(bitmapN.Planes[plane] + byte) |= 128>>(x&7);
  1485.             }
  1486.         }
  1487.     }
  1488. }
  1489. ///
  1490.  
  1491. /// Pixel2BitmapPens
  1492. void Pixel2BitmapPens(void)
  1493. {
  1494.     int x,y,plane,byte,lbyte,pen;
  1495.     unsigned int lbit;
  1496.  
  1497.     for (plane=0; plane<planesN; plane++) BltClear(bitmapN.Planes[plane],RASSIZE(gfx_width,gfx_height),0);
  1498.     for (y = 0; y < gfx_height; y++) {
  1499.         lbyte = y * bitmapN.BytesPerRow;
  1500.         lbit = lbyte << 3;
  1501.         for (x = 0; x < gfx_width; x++) {
  1502.             pen = Pens[picture[lbit + x]];
  1503.             byte = lbyte + (x>>3);
  1504.             for (plane = 0; plane < planesN; plane++) {
  1505.                 if (pen & (1<<plane)) *(bitmapN.Planes[plane] + byte) |= 128>>(x&7);
  1506.             }
  1507.         }
  1508.     }
  1509. }
  1510. ///
  1511.  
  1512. /// Pixel2BitmapPensOvl
  1513. void Pixel2BitmapPensOvl(void)
  1514. {
  1515.     int x,y,plane,byte,lbyte,pen;
  1516.     unsigned int lbit;
  1517.  
  1518.     for (plane=0; plane<planesN; plane++) BltClear(bitmapN.Planes[plane],RASSIZE(gfx_width,gfx_height),0);
  1519.     for (y = 0; y < gfx_height; y++) {
  1520.         lbyte = y * bitmapN.BytesPerRow;
  1521.         lbit = lbyte << 3;
  1522.         for (x = 0; x < gfx_width; x++) {
  1523.             pen = Pens[overlay[lbit + x]];
  1524.             if (pen > 15) pen = Pens[picture[lbit + x]];
  1525.             byte = lbyte + (x>>3);
  1526.             for (plane = 0; plane < planesN; plane++) {
  1527.                 if (pen & (1<<plane)) *(bitmapN.Planes[plane] + byte) |= 128>>(x&7);
  1528.             }
  1529.         }
  1530.     }
  1531. }
  1532. ///
  1533.  
  1534. /// Check_Win
  1535. void Check_Win(void)
  1536. {
  1537.     if (pic_w_hdl == NULL) {
  1538.         pic_w_hdl = (struct Window *) OpenWindowTags(NULL,WA_Title,"Graphics",WA_Left,win_pos_ver,WA_Top,win_pos_hor,
  1539.         WA_Width,win_width,WA_Height,win_height,WA_CloseGadget,FALSE,WA_DepthGadget,TRUE,WA_DragBar,TRUE,
  1540.         WA_IDCMP,IDCMP_CLOSEWINDOW,WA_CustomScreen,WBscreen,TAG_DONE);
  1541.         if (LDP) {
  1542.             rastPort = pic_w_hdl->RPort;
  1543.             rastPort->TmpRas = (struct TmpRas *) InitTmpRas(&tmp,(PLANEPTR)Rmem,RASSIZE(gfx_width,gfx_height));
  1544.         }
  1545.     }
  1546. } ///
  1547.  
  1548. /// Show_Overlay
  1549. void Show_Overlay(void)
  1550. {
  1551.     rle_decodeOvl(fgetc(gfx_in_file)*256 + fgetc(gfx_in_file));
  1552.     if (FASTCOLOURS) Pixel2BitmapFastOvl();
  1553.     else Pixel2BitmapPensOvl();
  1554.     BltBitMapRastPort(&bitmapN,0,0,pic_w_hdl->RPort,WBscreen->WBorLeft,
  1555.     WBscreen->WBorTop + WBscreen->Font->ta_YSize + 1,gfx_width,gfx_height,0xC0);
  1556. }///
  1557.  
  1558. /// Show_Anim
  1559. /*
  1560. void Show_Anim(void)
  1561. {
  1562.     Check_Win();
  1563. }*/
  1564. ///
  1565.  
  1566. /// Show_Pic
  1567. void Show_Pic(void)
  1568. {
  1569.     int     i;
  1570.  
  1571.     Check_Win();
  1572.     if (pic_w_hdl) {
  1573.         NumColours = fgetc(gfx_in_file); // how many colours
  1574.         if (NumColours > 16) {
  1575.             //printf("Cols: %d\n",NumColours);
  1576.             GFX_Off();
  1577.             EasyRequest(act_w_hdl,&NoGFX,NULL,"GFX datafile corrotto\o errato datafile (COL).\nGFX sarà esclusa.");
  1578.             if (pic_w_hdl) CloseWindow(pic_w_hdl);
  1579.             pic_w_hdl = 0;
  1580.             return;
  1581.         }
  1582.         for (i=0; i<NumColours; i++) {
  1583.             CR[i].red = fgetc(gfx_in_file)>>4;
  1584.             CR[i].green = fgetc(gfx_in_file)>>4;
  1585.             CR[i].blue = fgetc(gfx_in_file)>>4;
  1586.             //printf("Pen%2d: %3d %3d %3d\n",i+4,CR[i].red,CR[i].green,CR[i].blue);
  1587.             if (FASTCOLOURS) SetRGB4(&WBscreen->ViewPort,i,CR[i].red,CR[i].green,CR[i].blue);
  1588.             else SetRGB4(&WBscreen->ViewPort,Pens[i],CR[i].red,CR[i].green,CR[i].blue);
  1589.         }
  1590.  
  1591.         rle_decode(fgetc(gfx_in_file)*256 + fgetc(gfx_in_file));
  1592.         if (FASTCOLOURS) Pixel2BitmapFast();
  1593.         else Pixel2BitmapPens();
  1594.         BltBitMapRastPort(&bitmapN,0,0,pic_w_hdl->RPort,WBscreen->WBorLeft,
  1595.         WBscreen->WBorTop + WBscreen->Font->ta_YSize + 1,gfx_width,gfx_height,0xC0);
  1596.     }
  1597. }///
  1598.  
  1599. /// SetPen
  1600. void SetPen(UBYTE pen)
  1601. {
  1602.     if (FASTCOLOURS) SetAPen(rastPort,pen+4);
  1603.     else SetAPen(rastPort,Pens[pen]);
  1604. }///
  1605.  
  1606. /// DrawPicFrame
  1607. void DrawPicFrame(void)
  1608. {
  1609.     Move(rastPort,border_width-1,bar_height-1); //draw frame as border for fill
  1610.     Draw(rastPort,gfx_width+border_width,bar_height-1);
  1611.     Draw(rastPort,gfx_width+border_width,gfx_height+bar_height);
  1612.     Draw(rastPort,border_width-1,gfx_height+bar_height);
  1613.     Draw(rastPort,border_width-1,bar_height-1);
  1614. }///
  1615.  
  1616. /// DrawPic
  1617. void Draw_Pic(UBYTE pic_nr, UBYTE mode)
  1618. {
  1619.     UBYTE    command,col;
  1620.     UWORD    x,y;
  1621.  
  1622.     Check_Win();
  1623.     if (pic_w_hdl) {
  1624.         //OFF_DISPLAY;
  1625.         if (mode) {
  1626.             if ((fgetc(gfx_in_file)  != NEWPIC) || (fgetc(gfx_in_file) != pic_nr)) {
  1627.                 //printf("NewPic/PicNum: %d/%d (%d/%d)\n",dat1,dat2,NEWPIC,pic_nr);
  1628.                 GFX_Off();
  1629.                 EasyRequest(act_w_hdl,&NoGFX,NULL,"GFX datafile corrotto\o errato datafile (NEWPIC/COL).\nGFX sarà esclusa.");
  1630.                 if (pic_w_hdl) CloseWindow(pic_w_hdl);
  1631.                 pic_w_hdl = 0;
  1632.                 return;
  1633.             }
  1634.             col = fgetc(gfx_in_file);
  1635.             //printf("BackCol: %d\n",col);
  1636.             //if (col==7) col=1; //avoid white with UAE
  1637.             SetPen(col);
  1638.             RectFill(rastPort,border_width,bar_height,gfx_width-1+border_width,gfx_height-1+bar_height);
  1639.             col=(col==0)?7:0;
  1640.             SetPen(col);
  1641.             DrawPicFrame(); //in zeichenfarbe
  1642.             /*if (FASTCOLOURS) {
  1643.                 SafeSetOutlinePen(rastPort,col+4);
  1644.             }
  1645.             else {
  1646.                 SafeSetOutlinePen(rastPort,Pens[col]); //set bordercolor for FLOOD 0
  1647.             } */
  1648.             command = fgetc(gfx_in_file);
  1649.             while (command != NEWPIC) {
  1650.                 switch (command) {
  1651.                     case MOVE:
  1652.                         y = fgetc(gfx_in_file) + bar_height;
  1653.                         x = fgetc(gfx_in_file) + border_width;
  1654.                         //printf("MOVE: %d, %d - ",x,y);
  1655.                         Move(rastPort,x,y);
  1656.                         //getchar();
  1657.                         break;
  1658.                     case FILL:
  1659.                         col = fgetc(gfx_in_file);
  1660.                         y = fgetc(gfx_in_file) + bar_height;
  1661.                         x = fgetc(gfx_in_file) + border_width; //- 1;
  1662.                         SetPen(col);
  1663.                         //printf("FILL [%d]: %d, %d - ",col,x,y);
  1664.                         Flood(rastPort,1,x,y);
  1665.                         break;
  1666.                     default:  //DRAW
  1667.                         x = fgetc(gfx_in_file) + border_width;
  1668.                         //printf("DRAW: %d, %d - ",x,command + bar_height);
  1669.                         Draw(rastPort,x,command + bar_height);
  1670.                         break;
  1671.                 }
  1672.                 command = fgetc(gfx_in_file);
  1673.             }
  1674.             RefreshWindowFrame(pic_w_hdl);
  1675.             //printf("\n");
  1676.         }
  1677.         else { //it's dark out there
  1678.             SetPen(0); //black
  1679.             RectFill(rastPort,border_width,bar_height,gfx_width-1+border_width,gfx_height-1+bar_height);
  1680.             //DrawPicFrame(); //just to be on the safe side
  1681.         }
  1682.         //ON_DISPLAY;
  1683.     }
  1684. }///
  1685.  
  1686. /// Open_Pic
  1687. void Open_Pic(UBYTE pic_nr, UBYTE how)
  1688. {
  1689.     //printf("Showing Pic %d (%d)...\n",pic_nr,last_pic);
  1690.     if (go[pic_nr] != 0) { // there is definitely a picture for this room
  1691.         last_pic = pic_nr;
  1692.         fseek(gfx_in_file,go[pic_nr],SEEK_SET);
  1693.         switch (how) {
  1694.             case PIC:
  1695.                 if (LDP) { //LineDrawPic for Mysterious Adventures
  1696.                     if (pic_nr == 1) fseek(gfx_in_file,NumColours*3+1,SEEK_CUR); //BEFORE pic 1 is color-table --> ignore it for now
  1697.                     Draw_Pic(pic_nr,1);
  1698.                 }
  1699.                 else Show_Pic();
  1700.                 break;
  1701.             case COC:
  1702.                 break;
  1703.             case OVL:
  1704.                 Show_Overlay();
  1705.                 break;
  1706.             case ANI:
  1707.                 break;
  1708.             case GOT:
  1709.                 break;
  1710.             default:
  1711.                 break;
  1712.         }
  1713.     }
  1714.     else {
  1715.         //printf("Nessuna grafica per questa stanza!\n");
  1716.         if (pic_w_hdl) {
  1717.             win_pos_ver = pic_w_hdl->LeftEdge;
  1718.             win_pos_hor = pic_w_hdl->TopEdge;
  1719.             CloseWindow(pic_w_hdl);
  1720.             pic_w_hdl = 0;
  1721.             //if (LDP && Rmem) FreeRaster(Rmem,gfx_width,gfx_height);
  1722.         }
  1723.         last_pic = -128;
  1724.     }
  1725. }///
  1726.  
  1727. ///Handle_Pic
  1728. BOOL Handle_Pic(int Room)
  1729. {
  1730.     int i,j,yes,ii;
  1731.  
  1732.     //printf("%d Grafica(s) per Stanza %d.\n",rp[Room].ppr+1,MyLoc);
  1733.     if (rp[Room].ppr) {
  1734.         for (j=0; j<rp[Room].ppr; j++) {
  1735.             ii = rp[Room].what[j]-80;
  1736.             while (ii < 0) ii += 10;
  1737.             yes = 0;
  1738.             for (i=0; i<ii; i++) {
  1739.                 //printf("Switching to case %d!\n",rp[Room].loc[j][i]);
  1740.                 switch (rp[Room].loc[j][i]) {
  1741.                     case 1: // in room
  1742.                         if (Items[rp[Room].obj[j][i]].Location == MyLoc) yes++;
  1743.                         break;
  1744.                     case 2: // in inventory
  1745.                         if (Items[rp[Room].obj[j][i]].Location == 255) yes++;
  1746.                         break;
  1747.                     case 4: // in room or inventory
  1748.                         if ((Items[rp[Room].obj[j][i]].Location == 255) || (Items[rp[Room].obj[j][i]].Location == MyLoc)) yes++;
  1749.                         break;
  1750.                     case 81: // NOT in room
  1751.                         if (Items[rp[Room].obj[j][i]].Location != MyLoc) yes++;
  1752.                         break;
  1753.                     case 82: // NOT in inventory
  1754.                         if (Items[rp[Room].obj[j][i]].Location != 255) yes++;
  1755.                         break;
  1756.                     case 84: // NOT in room and NOT in inventory
  1757.                         if ((Items[rp[Room].obj[j][i]].Location != 255) && (Items[rp[Room].obj[j][i]].Location != MyLoc)) yes++;
  1758.                         break;
  1759.                     default:
  1760.                         break;
  1761.                 }
  1762.             }
  1763.             if (yes >= ii) {
  1764.                 if (rp[Room].pnr[j] == 0) { // no picture
  1765.                     //printf("Logic says: No Pic!\n");
  1766.                     if (pic_w_hdl) {
  1767.                         win_pos_ver = pic_w_hdl->LeftEdge;
  1768.                         win_pos_hor = pic_w_hdl->TopEdge;
  1769.                         CloseWindow(pic_w_hdl);
  1770.                         pic_w_hdl = 0;
  1771.                     }
  1772.                     last_pic = -128;
  1773.                     return(FALSE);
  1774.                 }
  1775.                 if (rp[Room].pnr[j] == 255) return(FALSE); // 255 = do nothing
  1776.                 if (last_pic >= 0) {
  1777.                     if ((go[last_pic] == go[rp[Room].pnr[j]])) return(FALSE);
  1778.                 }
  1779.                 //printf("Yes: %d, Last: %d - %d\n",yes,last_pic,rp[Room].pnr[j]);
  1780.                 switch ((int)(rp[Room].what[j]/10)) {
  1781.                     case PIC: // Show Pic
  1782.                         Open_Pic(rp[Room].pnr[j],PIC);
  1783.                         return(TRUE);
  1784.                     case COC: // colour cycling
  1785.                         //printf("Colour Cycling: %d\n",rp[Room].pnr[j]);
  1786.                         //return(TRUE);
  1787.                         break;
  1788.                     case OVL: // overlay picture
  1789.                         //printf("Overlay: %d\n",rp[Room].pnr[j]);
  1790.                         yes = 1;
  1791.                         if (last_pic != Room) {
  1792.                             for (i=0; i<rp[Room].ppr; i++) {
  1793.                                 if (last_pic == rp[Room].pnr[i]) {
  1794.                                     yes = 0;
  1795.                                     break;
  1796.                                 }
  1797.                             }
  1798.                         }
  1799.                         else yes = 0;
  1800.                         //printf("OVL [old pic too]: %d\n",yes);
  1801.                         if (yes) Open_Pic(Room,PIC); // basis pic is not already displayed
  1802.                         Open_Pic(rp[Room].pnr[j],OVL);
  1803.                         return(TRUE);
  1804.                         break;
  1805.                     case ANI: // animation
  1806.                         //printf("Animation: %d\n",rp[Room].pnr[j]);
  1807.                         //return(TRUE);
  1808.                         break;
  1809.                     case GOT: // GO_TREE for "Robin of Sherwood"
  1810.                         //printf("GO_TREE: %d\n",rp[Room].pnr[j]);
  1811.                         //return(TRUE);
  1812.                         break;
  1813.                     default:
  1814.                         //return(FALSE);
  1815.                         break;
  1816.                 }
  1817.             }
  1818.         }
  1819.     }
  1820.     if (last_pic >= 0) { // yes, last pic exits
  1821.         if (go[last_pic] == go[Room]) return(FALSE);
  1822.     }
  1823.     //printf("Std->Room: %d [%d is last]\n",Room,last_pic);
  1824.     Open_Pic(Room,PIC);
  1825.     return(TRUE);
  1826. }///
  1827.  
  1828.  
  1829. ///SpeakNum
  1830. void SpeakNum(int number)
  1831. {
  1832.     sprintf(str_buf,"%d",number);
  1833.     Speak(str_buf);
  1834. }
  1835. ///
  1836.